home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Amiga Plus 2004 #11
/
Amiga Plus CD - 2004 - No. 11.iso
/
AmiSoft
/
Misc
/
emu
/
p-interp.lha
/
p-interp-0.5
/
Memory.c‾
< prev
next >
Wrap
Text File
|
2001-06-07
|
6KB
|
294 lines
/*
P-Code interpreter (to run the apple pascal system)
Copyright (C) 2000 Mario Klebsch
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
$Log: Memory.c,v $
Revision 1.5 2001/06/06 23:26:44 mario
Amiga-Patch von "Stefan A. Haubenthal" <polluks@web.de>
Revision 1.4 2001/05/26 15:13:29 mario
Diverse kleine Fehler behoben, fehlende #includes, Labels ohne Statement
dahinter, ...
Revision 1.3 2001/05/21 20:47:06 mario
Die einzelnen Bits der Speicherflags können jetzt einzeln abbestellt
werden.
Revision 1.2 2001/05/20 13:12:02 mario
CVS-Idents und Logs eingefügt
*/
#ident "$Id: Memory.c,v 1.5 2001/06/06 23:26:44 mario Exp $";
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include "psystem.h"
#include "pcode.h"
#include "Memory.h"
#ifdef XXX
#define MEM_VALID 1
#define MEM_RD_ONLY 2
#define MEM_WARN 4
#endif
int SwapBytes=0;
typedef struct Memory_St
{
#ifdef WORD_MEMORY
word Value;
#else
byte Value;
#endif
byte Flags;
} Memory_t;
#ifdef __SASC
__far
#endif
Memory_t Mem[0x10000];
#ifdef WORD_MEMORY
word MemRd(word Addr)
{
PointerCheck(Addr);
#ifdef MEM_VALID
if (!(Mem[Addr].Flags&MEM_VALID))
warning("MemRdByte: Reading uninitialized Memory 0x%04x",Addr);
#endif
#ifdef MEM_WARN
if (Mem[Addr].Flags&MEM_WARN)
warning("MemRdByte: Access to 0x%04x", Addr);
#endif
return(Mem[Addr].Value);
}
void MemWr(word Addr, word Value)
{
PointerCheck(Addr);
#ifdef MEM_RD_ONLY
if (Mem[Addr].Flags&MEM_RD_ONLY)
{
warning("MemWrByte: 0x%04x is read only", Addr);
XeqError(XBADMEM);
}
#endif
#ifdef MEM_WARN
if (Mem[Addr].Flags&MEM_WARN)
warning("MemWrByte: Access to 0x%04x", Addr);
#endif
Mem[Addr].Value=Value;
#ifdef MEM_VALID
Mem[Addr].Flags|=MEM_VALID;
#endif
}
byte MemRdByte(word Addr, Integer Offset)
{
PointerCheck(Addr);
Addr += (Offset&~1)/2;
Offset &= 1;
if (Offset)
return(MemRd(Addr)>>8);
else
return(MemRd(Addr)&0xff);
}
void MemWrByte(word Addr, Integer Offset, byte Value)
{
word w;
PointerCheck(Addr);
Addr += (Offset&~1)/2;
Offset &= 1;
w=MemRd(Addr);
if (Offset)
w=(w&0x00ff)|(Value<<8);
else
w=(w&0xff00)|(Value&0xff);
MemWr(Addr, w);
}
#else
byte MemRdByte(word Addr, Integer Offset)
{
PointerCheck(Addr);
Addr += Offset;
#ifdef MEM_VALID
if (!(Mem[Addr].Flags&MEM_VALID))
warning("MemRdByte: Reading uninitialized Memory 0x%04x",Addr);
#endif
#ifdef MEM_WARN
if (Mem[Addr].Flags&MEM_WARN)
warning("MemRdByte: Access to 0x%04x", Addr);
#endif
return(Mem[Addr].Value);
}
void MemWrByte(word Addr, Integer Offset, byte Value)
{
PointerCheck(Addr);
Addr += Offset;
#ifdef MEM_RD_ONLY
if (Mem[Addr].Flags&MEM_RD_ONLY)
{
warning("MemWrByte: 0x%04x is read only", Addr);
XeqError(XBADMEM);
}
#endif
#ifdef MEM_WARN
if (Mem[Addr].Flags&MEM_WARN)
warning("MemWrByte: Access to 0x%04x", Addr);
#endif
Mem[Addr].Value=Value;
#ifdef MEM_VALID
Mem[Addr].Flags|=MEM_VALID;
#endif
}
word MemRd(word Addr)
{
PointerCheck(Addr);
return ( MemRdByte(Addr, 0+SwapBytes) +
(MemRdByte(Addr, 1-SwapBytes)<<8) );
}
void MemWr(word Addr, word Value)
{
PointerCheck(Addr);
MemWrByte(Addr, 0+SwapBytes, Value & 0xff);
MemWrByte(Addr, 1+SwapBytes, Value >> 8);
}
#endif
void MemReadOnly(word from, word to, int RO)
{
#ifdef MEM_RD_ONLY
while (from<=to)
{
if (RO)
Mem[from].Flags|=MEM_RD_ONLY;
else
Mem[from].Flags&=~MEM_RD_ONLY;
from++;
}
#endif
}
void MemDump(FILE *f, word Start, word End)
{
int w;
int i;
int Count=0;
#ifdef WORD_MEMORY
word Value;
char b[6];
byte ch1;
#else
byte Value;
char b[4];
#endif
byte ch;
char Buffer[80];
char OldBuffer[80];
OldBuffer[0]='\0';
for (w=Start; w<=End;)
{
#ifdef WORD_MEMORY
w=w&0xfff8;
#else
w=w&0xfff0;
#endif
sprintf(Buffer,"%04x: %48s %16s\n",w,"","");
#ifdef WORD_MEMORY
for (i=0;i< 8;i++)
#else
for (i=0;i<16;i++)
#endif
{
#ifdef MEM_VALID
if (Mem[w].Flags&MEM_VALID)
{
#endif /* MEM_VALID */
Value=Mem[w].Value;
#ifdef WORD_MEMORY
sprintf(b,"%04x",Value);
#else
sprintf(b,"%02x",Value);
#endif
ch=Value&0xff;
if (!isprint(ch))
ch='.';
#ifdef WORD_MEMORY
ch1=Value>>8;
if (!isprint(ch1))
ch1='.';
#endif
#ifdef MEM_VALID
}
else
{
#ifdef WORD_MEMORY
strcpy(b,"....");
ch1=' ';
#else
strcpy(b,"..");
#endif
ch=' ';
}
#endif /* MEM_VALID */
#ifdef WORD_MEMORY
Buffer[6+5*i ]=b[0];
Buffer[6+5*i+1 ]=b[1];
Buffer[6+5*i+2 ]=b[2];
Buffer[6+5*i+3 ]=b[3];
Buffer[6+5*8+2*i ]=ch;
Buffer[6+5*8+2*i+1]=ch1;
#else
Buffer[6+3*i ]=b[0];
Buffer[6+3*i+1 ]=b[1];
Buffer[6+3*16+i]=ch;
#endif
w++;
}
if (strcmp(Buffer+4, OldBuffer+4)!=0)
{
if (Count>1)
fprintf(f, ".... %d line%s omitted\n",Count-1, Count==2?"":"s");
if (Count>0)
fputs(OldBuffer, f);
Count=0;
fputs(Buffer, f);
}
else
Count++;
strcpy(OldBuffer,Buffer);
}
}
void MemInit(void)
{
memset(Mem, 0, sizeof(Mem));
}